# 方法一
'''
💡思路点拨
一直都是暴力解法q(≧▽≦q)
'''
'''
n, m = map(int, input().split())
a = [list(map(int, input().split())) for i in range(n)]  # 通过列表推导式读取整个矩阵。

# 初始化变量 ans 为 0，用于累计每一行的第一个元素之和。
ans = 0
# 使用一个 while 循环，当 m 大于 0 时，执行以下操作：
while m > 0:
    a = sorted(a, key=lambda x: x[0], reverse=True)  # 每次都从大到小排序,将矩阵按第一列的值从大到小排序。
    # key=lambda x: x[0]：这是排序的关键字参数。这里使用了一个lambda函数，该函数接受一个元素x作为输入，并返回该元素的第一个子元素（即索引为0的元素）作为排序的依据。这意味着这段代码是按照列表中每个子列表的第一个元素进行排序。
    ans += a[0][0]  # 将排序后的第一行的第一个元素加到 ans 上。
    a[0][0] -= a[0][1]  # 从第一行的第一个元素中减去第一行的第二个元素。
    m -= 1
print(ans)

# 这段代码的目的是计算每一行的第一个元素中，最大的和是多少。
# 因为在每一行中，第一个元素总是比上一行的第一个元素大，所以最大和就是从第一行到最后一行，每个第一行的第一个元素之和。
'''


'''
input:
3 6
10 5
9 2
8 1
print:
47
demo:
[[10, 5], [9, 2], [8, 1]]
[[9, 2], [8, 1], [5, 5]]
[[8, 1], [7, 2], [5, 5]]
[[7, 1], [7, 2], [5, 5]]
[[7, 2], [6, 1], [5, 5]]
[[6, 1], [5, 2], [5, 5]]
'''

'''
n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]  # 这一次性读取 n 行整数数据
# 使用input().split()读取一行数据并按空格分割。接着，使用map(int, ...)将每个单词转化为整数，并使用list(...)将map对象转化为列表。最后，将结果存储在列表a中。
result = 0
while m > 0:
    a = sorted(a, key=lambda x:x[0], reverse=True)
    result += a[0][0]
    a[0][0] -= a[0][1]
    m -= 1
print(result)
'''

# 方法二
'''
import math
n, m = list(map(int, input().split()))
mp = {}  # 字典进行存储
for i in range(0, n):
    Ai, Bi = list(map(int, input().split()))
    mp[i + 1] = [Ai, Bi, 0]
# print(mp)  # {1: [10, 5, 0], 2: [9, 2, 0], 3: [8, 1, 0]}
temp = sorted(mp.items(), key=lambda mp: mp[1][0], reverse=True)  # 通过当前value进行排序
# print(temp)  # [(1, [10, 5, 0]), (2, [9, 2, 0]), (3, [8, 1, 0])]
res = 0
for i in range(0, m):
    index = temp[0][0]
    A = temp[0][1][0]
    B = temp[0][1][1]
    times = temp[0][1][2]
    # print(index,A,B,times)
    if times >= math.ceil(A / B):  # 如果当前此技能已经升到满级了，就置零
        A = 0
        B = 0
    res += A
    A -= B
    times += 1
    mp[index] = [A, B, times]  # 善后处理，重新排序
    temp = sorted(mp.items(), key=lambda mp: mp[1][0], reverse=True)
print(res)
'''




# 方法三
'''
n,m = map(int,input().split())
a = []
b = []
for i in range(n):
    a_,b_ = map(int,input().split())
    a.append(a_)
    b.append(b_)

# 1、要获得最大攻击力则每次升级技能都需要升级提升攻击力最大的技能
# 2、最后一次升级技能提升的攻击力一定小于或等于前面升级技能提升的攻击力
# 3、每次升级技能则下次升级技能都会减少固定值，设每次升级技能提升的攻击力为a，升级后有 a=a-b
# 4、设最后一次升级技能提升的攻击力为mid，则当 a<mid 时，技能不会被升级，设技能被升级x次，则有 a - xb < mid
# 5、由4可求x，则可算出所有技能的x即求出所有技能被升级的次数，所有x相加，若小于m则说明mid大了，大于或等于m则说明mid小了
# 6、由以上可知，二分查找出mid可以知道每个技能升级的次数，则可知道升级某个技能获得的攻击力为：a+(a-b)+(a-2b)+...+[a-(n-1)b]=n*a+n*(n-1)*b/2
# 7、由6累加每个技能提升的攻击力可得提升的总攻击力
def check(mid):
    cnt = 0
    for i in range(n):
        if a[i] < mid:
            continue
        t = (a[i]-mid) // b[i] + 1
        cnt += t
        if cnt >= m:
            return True
    return False

# 二分枚举最后一次升级技能提升了多少攻击力
l = 0
r = 1000000
while l <= r:
    mid = (l+r)//2
    if check(mid):
        l = mid + 1
    else:
        r = mid - 1

attack = 0
surplus = m
for i in range(n):
    if a[i] < r:
        continue
    t = (a[i]-l) // b[i] + 1
    if a[i] - (t-1)*b[i] == r:
        t -= 1
    attack += a[i]*t - t*(t-1)*b[i] / 2
    surplus -= t # 可能surplus不为零，因为有的技能刚好提升了mid攻击力
print(int(attack) + surplus*r)
'''


# 方法四
n,m = map(int,input().split())
a = []
b = []
for i in range(n):
    a_,b_ = map(int,input().split())
    a.append(a_)
    b.append(b_)
# print(a)  # [10, 9, 8]
# print(b)  # [5, 2, 1]
c = []
for i in range(n):
    for j in range(1, a[i] // b[i] + 1):
        if j == 1:
            c.append(a[i])
        else:
            c.append(a[i] - b[i]*(j-1))
c.sort(reverse=True)
# print(c) # [10, 9, 8, 7, 7, 6, 5, 5, 5, 4, 3, 3, 2, 1]
result = sum(c[:m])
print(result)


